home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / olecon~1 / framewrk / ctlembed.cpp < prev    next >
Text File  |  1995-11-30  |  57KB  |  1,967 lines
  1. //=--------------------------------------------------------------------------=
  2. // ControlEmbedding.Cpp
  3. //=--------------------------------------------------------------------------=
  4. // Copyright  1995  Microsoft Corporation.  All Rights Reserved.
  5. //
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  7. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  8. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  9. // PARTICULAR PURPOSE.
  10. //=--------------------------------------------------------------------------=
  11. //
  12. // implementation of the interfaces required for inplace activation for
  13. // COleControl
  14. //
  15. #include "IPServer.H"
  16. #include "CtrlObj.H"
  17. #include "CtlHelp.H"
  18. #include "Globals.H"
  19. #include "StdEnum.H"
  20. #include "Util.H"
  21.  
  22. // for ASSERT and FAIL
  23. //
  24. SZTHISFILE
  25.  
  26.  
  27. //=--------------------------------------------------------------------------=
  28. // all controls support the following in-place verbs at an absolute minimum.
  29. //
  30. #define CINPLACEVERBS 4
  31.  
  32. const VERBINFO rgInPlaceVerbs [] = {
  33.     { OLEIVERB_SHOW,            0, 0, 0},
  34.     { OLEIVERB_HIDE,            0, 0, 0},
  35.     { OLEIVERB_INPLACEACTIVATE, 0, 0, 0},
  36.     { OLEIVERB_PRIMARY,         0, 0, 0}
  37. };
  38.  
  39. // NOTE: Resource ID for Properties string must be 1000
  40. //
  41. const VERBINFO ovProperties =
  42.     { CTLIVERB_PROPERTIES, 1000, 0, OLEVERBATTRIB_ONCONTAINERMENU };
  43.  
  44. const VERBINFO ovUIActivate =
  45.     { OLEIVERB_UIACTIVATE, 0, 0, 0};
  46.  
  47.  
  48. //=--------------------------------------------------------------------------=
  49. // COleControl::GetControlInfo    (IOleControl)
  50. //=--------------------------------------------------------------------------=
  51. // returns some information on a control, such as an accelerator table, and
  52. // flags.  really used for keyboard handling and mnemonics
  53. //
  54. // Parameters:
  55. //    CONTROLINFO *        - [in]  where to put said information
  56. //
  57. // Output:
  58. //    HRESULT              - S_OK
  59. //
  60. // Notes:
  61. //
  62. STDMETHODIMP COleControl::GetControlInfo
  63. (
  64.     CONTROLINFO *pControlInfo
  65. )
  66. {
  67.     CHECK_POINTER(pControlInfo);
  68.  
  69.     // certain hosts have a bug in which it doesn't initialize the cb in the
  70.     // CONTROLINFO structure, so we can only assert on that here.
  71.     // maggots!
  72.     //
  73.     ASSERT(pControlInfo->cb == sizeof(CONTROLINFO), "Host doesn't initialize CONTROLINFO structure");
  74.  
  75.     pControlInfo->hAccel = m_hAccel;
  76.     pControlInfo->cAccel = m_cAccel;
  77.  
  78.     return S_OK;
  79. }
  80.  
  81. //=--------------------------------------------------------------------------=
  82. // COleControl::OnMnemonic    [IOleControl]
  83. //=--------------------------------------------------------------------------=
  84. // the container has decided to pass on a key that the end-user has pressed to
  85. // us.  default implementation will be to just activate the control.  people
  86. // looking for more functionality should override this method.
  87. //
  88. // Parameters:
  89. //    LPMSG                - [in] message for this mnemonic
  90. //
  91. // Output:
  92. //    HRESULT              - S_OK, E_POINTER
  93. //
  94. // Notes:
  95. //
  96. STDMETHODIMP COleControl::OnMnemonic
  97. (
  98.     LPMSG pMsg
  99. )
  100. {
  101.     // default implementation is to just activate our control.  user can override
  102.     // if they want more interesting behaviour.
  103.     //
  104.     return InPlaceActivate(OLEIVERB_UIACTIVATE);
  105. }
  106.  
  107. //=--------------------------------------------------------------------------=
  108. // COleControl:OnAmbientPropertyChange    [IOleControl]
  109. //=--------------------------------------------------------------------------=
  110. // a container calls this whenever it changes an ambient property.
  111. //
  112. // Parameters:
  113. //    DISPID            - [in] dispid of the property that changed.
  114. //
  115. // Output:
  116. //    HRESULT           - S_OK
  117. //
  118. // Notes:
  119. //
  120. STDMETHODIMP COleControl::OnAmbientPropertyChange
  121. (
  122.     DISPID dispid
  123. )
  124. {
  125.     // if we're being told about a change in mode [design/run] then
  126.     // remember that so our stashing of mode will update itself
  127.     // correctly
  128.     //
  129.     if (dispid == DISPID_AMBIENT_USERMODE || dispid == DISPID_UNKNOWN)
  130.         m_fModeFlagValid = FALSE;
  131.  
  132.     // just pass this on to the derived control and see if they want
  133.     // to do anything with it.
  134.     //
  135.     AmbientPropertyChanged(dispid);
  136.     return S_OK;
  137. }
  138.  
  139. //=--------------------------------------------------------------------------=
  140. // COleControL::FreezeEvents    [IOleControl]
  141. //=--------------------------------------------------------------------------=
  142. // allows a container to freeze all of a controls events.  when events are
  143. // frozen, a control will not fire any of them.
  144. //
  145. // Parameters:
  146. //    BOOL            - [in] TRUE means FREEZE, FALSE means THAW
  147. //
  148. // Output:
  149. //    HRESULT         - S_OK
  150. //
  151. // Notes:
  152. //    - we maintain an internal count of freezes versus thaws.
  153. //
  154. STDMETHODIMP COleControl::FreezeEvents
  155. (
  156.     BOOL fFreeze
  157. )
  158. {
  159.     // by default, we don't care.  user can override if they want to.
  160.     //
  161.     return S_OK;
  162. }
  163.  
  164. //=--------------------------------------------------------------------------=
  165. // COleControl::SetClientSite    [IOleObject]
  166. //=--------------------------------------------------------------------------=
  167. // informs the embedded object [control] of it's client site [display
  168. // location] within it's container
  169. //
  170. // Parameters:
  171. //    IOleClientSite *        - [in] pointer to client site.
  172. //
  173. // Output:
  174. //    HRESULT                 - S_OK, E_UNEXPECTED
  175. //
  176. // Notes:
  177. //
  178. STDMETHODIMP COleControl::SetClientSite
  179. (
  180.     IOleClientSite *pClientSite
  181. )
  182. {
  183.     RELEASE_OBJECT(m_pClientSite);
  184.     RELEASE_OBJECT(m_pControlSite);
  185.     RELEASE_OBJECT(m_pSimpleFrameSite);
  186.  
  187.     // store away the new client site
  188.     //
  189.     m_pClientSite = pClientSite;
  190.  
  191.     // if we've actually got one, then get some other interfaces we want to keep
  192.     // around, and keep a handle on it
  193.     //
  194.     if (m_pClientSite) {
  195.         m_pClientSite->AddRef();
  196.         m_pClientSite->QueryInterface(IID_IOleControlSite, (void **)&m_pControlSite);
  197.  
  198.         if (OLEMISCFLAGSOFCONTROL(m_ObjectType) & OLEMISC_SIMPLEFRAME)
  199.             m_pClientSite->QueryInterface(IID_ISimpleFrameSite, (void **)&m_pSimpleFrameSite);
  200.     }
  201.  
  202.     return S_OK;
  203. }
  204.  
  205. //=--------------------------------------------------------------------------=
  206. // COleControl::GetClientSite    [IOleObject]
  207. //=--------------------------------------------------------------------------=
  208. // obtains a pointer to the controls client site.
  209. //
  210. // Parameters:
  211. //    IOleClientSite **        - [out]
  212. //
  213. // Output:
  214. //    HRESULT                  - S_OK
  215. //
  216. // Notes:
  217. //
  218. STDMETHODIMP COleControl::GetClientSite
  219. (
  220.     IOleClientSite **ppClientSite
  221. )
  222. {
  223.     CHECK_POINTER(ppClientSite);
  224.  
  225.     *ppClientSite = m_pClientSite;
  226.     ADDREF_OBJECT(*ppClientSite);
  227.     return S_OK;
  228. }
  229.  
  230. //=--------------------------------------------------------------------------=
  231. // COleControl::SetHostNames    [IOleObject]
  232. //=--------------------------------------------------------------------------=
  233. // Provides the control with the name of its container application and the
  234. // compound document in which it is embedded
  235. //
  236. // Parameters:
  237. //    LPCOLESTR        - [in] name of container application
  238. //    LPCOLESTR        - [in] name of container document
  239. //
  240. // Output:
  241. //    HRESULT          - S_OK
  242. //
  243. // Notes:
  244. //    - we don't care about this
  245. //
  246. STDMETHODIMP COleControl::SetHostNames
  247. (
  248.     LPCOLESTR szContainerApp,
  249.     LPCOLESTR szContainerObject
  250. )
  251. {
  252.     // we don't care about these
  253.     //
  254.     return S_OK;
  255. }
  256.  
  257. //=--------------------------------------------------------------------------=
  258. // COleControl::Close    [IOleObject]
  259. //=--------------------------------------------------------------------------=
  260. // Changes the control from the running to the loaded state
  261. //
  262. // Parameters:
  263. //    DWORD             - [in] indicates whether to save the object before closing
  264. //
  265. // Output:
  266. //    HRESULT           - S_OK, OLE_E_PROMPTSAVECANCELLED
  267. //
  268. // Notes:
  269. //
  270. STDMETHODIMP COleControl::Close
  271. (
  272.     DWORD dwSaveOption
  273. )
  274. {
  275.     HRESULT hr;
  276.  
  277.     if (m_fInPlaceActive) {
  278.         hr = InPlaceDeactivate();
  279.         RETURN_ON_FAILURE(hr);
  280.     }
  281.  
  282.     return S_OK;
  283. }
  284.  
  285. //=--------------------------------------------------------------------------=
  286. // COleControl::SetMoniker    [IOleObject]
  287. //=--------------------------------------------------------------------------=
  288. // Notifies an object of its container's moniker, the object's own moniker
  289. // relative to the container, or the object's full moniker
  290. //
  291. // Parameters:
  292. //    DWORD                - [in] which moniker is being set
  293. //    IMoniker *           - [in] the moniker
  294. //
  295. // Output:
  296. //    HRESULT              - S_OK, E_FAIL
  297. //
  298. // Notes:
  299. //    - we don't support monikers.
  300. //
  301. STDMETHODIMP COleControl::SetMoniker
  302. (
  303.     DWORD     dwWhichMoniker,
  304.     IMoniker *pMoniker
  305. )
  306. {
  307.     // homey don't play that.
  308.     //
  309.     return E_NOTIMPL;
  310. }
  311.  
  312. //=--------------------------------------------------------------------------=
  313. // COleControl::GetMoniker    [IOleObject]
  314. //=--------------------------------------------------------------------------=
  315. // Returns a embedded object's moniker, which the caller can use to link to
  316. // the object
  317. //
  318. // Parameters:
  319. //    DWORD            - [in]  how it's assigned
  320. //    DWORD            - [in]  which moniker
  321. //    IMoniker **      - [out] duh.
  322. //
  323. // Output:
  324. //    HRESULT          - E_NOTIMPL
  325. //
  326. // Notes:
  327. //    - we don't support monikers
  328. //
  329. STDMETHODIMP COleControl::GetMoniker
  330. (
  331.     DWORD      dwAssign,
  332.     DWORD      dwWhichMoniker,
  333.     IMoniker **ppMonikerOut
  334. )
  335. {
  336.     // homey don't play that
  337.     //
  338.     return E_NOTIMPL;
  339. }
  340.  
  341. //=--------------------------------------------------------------------------=
  342. // COleControl::InitFromData    [IOleObject]
  343. //=--------------------------------------------------------------------------=
  344. // Initializes a newly created object with data from a specified data object,
  345. // which can reside either in the same container or on the Clipboard
  346. //
  347. // Parameters:
  348. //    IDataObject*    - [in] data object with the data
  349. //    BOOL            - [in] how object is created
  350. //    DWORD           - reserved
  351. //
  352. // Output:
  353. //    HRESULT         - S_OK, S_FALSE, E_NOTIMPL, OLE_E_NOTRUNNING
  354. //
  355. // Notes:
  356. //    - we don't have data object support
  357. //
  358. STDMETHODIMP COleControl::InitFromData
  359. (
  360.     IDataObject *pDataObject,
  361.     BOOL         fCreation,
  362.     DWORD        dwReserved
  363. )
  364. {
  365.     return E_NOTIMPL;
  366. }
  367.  
  368. //=--------------------------------------------------------------------------=
  369. // COleControl::GetClipboardData    [IOleObject]
  370. //=--------------------------------------------------------------------------=
  371. // Retrieves a data object containing the current contents of the control.
  372. // Using the pointer to this data object, it is possible to create a new control
  373. // with the same data as the original
  374. //
  375. // Parameters:
  376. //    DWORD          - reserved
  377. //    IDataObject ** - [out] data object for this control
  378. //
  379. // Output:
  380. //    HREUSLT        - S_OK, E_NOTIMPL, OLE_E_NOTRUNNING
  381. //
  382. // Notes:
  383. //
  384. STDMETHODIMP COleControl::GetClipboardData
  385. (
  386.     DWORD         dwReserved,
  387.     IDataObject **ppDataObject
  388. )
  389. {
  390.     *ppDataObject = NULL;        // be a good neighbour
  391.     return E_NOTIMPL;
  392. }
  393.  
  394. //=--------------------------------------------------------------------------=
  395. // COleControl::DoVerb    [IOleObject]
  396. //=--------------------------------------------------------------------------=
  397. // Requests an object to perform an action in response to an end-user's
  398. // action.
  399. //
  400. // Parameters:
  401. //    LONG             - [in]  verb to be performed
  402. //    LPMSG            - [in]  event that invoked the verb
  403. //    IOleClientSite * - [in]  the controls active client site
  404. //    LONG             - [in]  reserved
  405. //    HWND             - [in]  handle of window containing the object.
  406. //    LPCRECT          - [in]  pointer to objects's display rectangle
  407. //
  408. // Output:
  409. //    HRESULT          - S_OK, OLE_E_NOTINPLACEACTIVE, OLE_E_CANT_BINDTOSOURCE,
  410. //                       DV_E_LINK, OLEOBJ_S_CANNOT_DOVERB_NOW, OLEOBJ_S_INVALIDHWND,
  411. //                       OLEOBJ_E_NOVERBS, OLEOBJ_S_INVALIDVERB, MK_E_CONNECT,
  412. //                       OLE_CLASSDIFF, E_NOTIMPL
  413. //
  414. // Notes:
  415. //
  416. STDMETHODIMP COleControl::DoVerb
  417. (
  418.     LONG            lVerb,
  419.     LPMSG           pMsg,
  420.     IOleClientSite *pActiveSite,
  421.     LONG            lIndex,
  422.     HWND            hwndParent,
  423.     LPCRECT         prcPosRect
  424. )
  425. {
  426.     HRESULT hr;
  427.  
  428.     switch (lVerb) {
  429.       case OLEIVERB_SHOW:
  430.       case OLEIVERB_INPLACEACTIVATE:
  431.       case OLEIVERB_UIACTIVATE:
  432.         return InPlaceActivate(lVerb);
  433.  
  434.       case OLEIVERB_HIDE:
  435.         UIDeactivate();
  436.         if (m_fInPlaceVisible) SetInPlaceVisible(FALSE);
  437.         return S_OK;
  438.  
  439.       // we used to have OLEIVERB_PRIMARY InPlaceActivate Ourselves, but it
  440.       // turns out that the CDK and certain hosts expect this to show the
  441.       // properties instead.  Users can change what this verb does at will.
  442.       //
  443.       case OLEIVERB_PRIMARY:
  444.       case CTLIVERB_PROPERTIES:
  445.       case OLEIVERB_PROPERTIES:
  446.         {
  447.         // show the frame ourselves if the hose can't.
  448.         //
  449.         if (m_pControlSite) {
  450.             hr = m_pControlSite->ShowPropertyFrame();
  451.             if (hr != E_NOTIMPL)
  452.                 return hr;
  453.         }
  454.         IUnknown *pUnk = (IUnknown *)(IOleObject *)this;
  455.         MAKE_WIDEPTR_FROMANSI(pwsz, NAMEOFOBJECT(m_ObjectType));
  456.  
  457.         ModalDialog(TRUE);
  458.         hr = OleCreatePropertyFrame(GetActiveWindow(),
  459.                             GetSystemMetrics(SM_CXSCREEN) / 2,
  460.                             GetSystemMetrics(SM_CYSCREEN) / 2,
  461.                             pwsz,
  462.                             1,
  463.                             &pUnk,
  464.                             CPROPPAGESOFCONTROL(m_ObjectType),
  465.                             (LPCLSID)*(PPROPPAGESOFCONTROL(m_ObjectType)),
  466.                             g_lcidLocale,
  467.                             NULL, NULL);
  468.         ModalDialog(FALSE);
  469.         return hr;
  470.         }
  471.  
  472.       default:
  473.         // if it's a derived-control defined verb, pass it on to them
  474.         //
  475.         if (lVerb > 0) {
  476.             hr = DoCustomVerb(lVerb);
  477.  
  478.             if (hr == OLEOBJ_S_INVALIDVERB) {
  479.                 // unrecognised verb -- just do the primary verb and
  480.                 // activate the sucker.
  481.                 //
  482.                 hr = InPlaceActivate(OLEIVERB_PRIMARY);
  483.                 return (FAILED(hr)) ? hr : OLEOBJ_S_INVALIDVERB;
  484.             } else
  485.                 return hr;
  486.         } else {
  487.             FAIL("Unrecognized Negative verb in DoVerb().  bad.");
  488.             return E_NOTIMPL;
  489.         }
  490.         break;
  491.     }
  492.  
  493.     // dead code
  494.     FAIL("Gaaaaaak! this should be dead code!");
  495. }
  496.  
  497. //=--------------------------------------------------------------------------=
  498. // COleControl::EnumVerbs    [IOleObject]
  499. //=--------------------------------------------------------------------------=
  500. // create an enumerator object for the verbs this object supports.
  501. //
  502. // Parameters:
  503. //    IEnumOleVERB **    - [out] new enumerator.
  504. //
  505. // Output:
  506. //    HRESULT            - S_OK, E_OUTOFMEMORY
  507. //
  508. // Notes:
  509. //
  510. STDMETHODIMP COleControl::EnumVerbs
  511. (
  512.     IEnumOLEVERB **ppEnumVerbs
  513. )
  514. {
  515.     int cVerbs;
  516.     OLEVERB *rgVerbs, *pVerb;
  517.  
  518.     DWORD dw = OLEMISCFLAGSOFCONTROL(m_ObjectType);
  519.     BOOL fCanInPlace = !(dw & OLEMISC_INVISIBLEATRUNTIME) || (dw & OLEMISC_ACTIVATEWHENVISIBLE);
  520.     BOOL fCanUIActivate = !(dw & OLEMISC_NOUIACTIVATE);
  521.     BOOL fHasProperties = (CPROPPAGESOFCONTROL(m_ObjectType) != 0);
  522.  
  523.     int cVerbExtra = CCUSTOMVERBSOFCONTROL(m_ObjectType);
  524.  
  525.     // count up all the verbs
  526.     //
  527.     cVerbs = (fCanInPlace ? CINPLACEVERBS : 0) + (fCanUIActivate ? 1 : 0)
  528.              + (fHasProperties ? 1 : 0) + cVerbExtra;
  529.  
  530.     // if there aren't any, this suddenly gets really easy !
  531.     //
  532.     if (cVerbs == 0)
  533.         return OLEOBJ_E_NOVERBS;
  534.  
  535.     // HeapAlloc some storage for these dudes so that we can pass them on to
  536.     // the standard enumerator!
  537.     //
  538.     if (! (rgVerbs = (OLEVERB *)HeapAlloc(g_hHeap, 0, cVerbs * sizeof(OLEVERB))))
  539.         return E_OUTOFMEMORY;
  540.   
  541.     // start copying over verbs.  first, the in-place guys
  542.     //
  543.     pVerb = rgVerbs;
  544.     if (fCanInPlace) {
  545.         memcpy(pVerb, rgInPlaceVerbs, CINPLACEVERBS * sizeof(OLEVERB));
  546.         pVerb += CINPLACEVERBS;
  547.       }
  548.  
  549.     if (fCanUIActivate)
  550.         memcpy(pVerb++, &ovUIActivate, sizeof(OLEVERB));
  551.  
  552.     // if their control has properties, copy that over now.
  553.     //
  554.     if (fHasProperties) {
  555.         memcpy(pVerb, &ovProperties, sizeof(OLEVERB));
  556.         pVerb++;
  557.     }
  558.  
  559.     // finally, any custom verbs!
  560.     //
  561.     if (cVerbExtra) {
  562.         memcpy(pVerb, CUSTOMVERBSOFCONTROL(m_ObjectType), sizeof(OLEVERB) * cVerbExtra);
  563.     }
  564.  
  565.     *ppEnumVerbs = (IEnumOLEVERB *) (IEnumGeneric *) new CStandardEnum(IID_IEnumOLEVERB,
  566.                                      cVerbs, sizeof(OLEVERB), rgVerbs, CopyOleVerb);
  567.     if (!*ppEnumVerbs)
  568.         return E_OUTOFMEMORY;
  569.  
  570.     // this forces us to go and look for the Localized DLLs.  This is necessary here
  571.     // because the CopyOleVerb will get information from localized resources, but
  572.     // will only use the global GetResourceHandle, which only uses the global value
  573.     // for the LCID.  This turns out to not be a big performance hit, since this
  574.     // function is typically only called in design mode, and we stash this value.
  575.     //
  576.     GetResourceHandle();
  577.     return S_OK;
  578. }
  579.  
  580. //=--------------------------------------------------------------------------=
  581. // COleControl::Update    [IOleObject]
  582. //=--------------------------------------------------------------------------=
  583. // Updates an object handler's or link object's data or view caches.
  584. //
  585. // Output:
  586. //    HRESULT            - S_OK
  587. //
  588. // Notes:
  589. //
  590. STDMETHODIMP COleControl::Update
  591. (
  592.     void
  593. )
  594. {
  595.     // nothing to do!!!
  596.     //
  597.     return S_OK;
  598. }
  599.  
  600. //=--------------------------------------------------------------------------=
  601. // COleControl::IsUpToDate    [IOleObject]
  602. //=--------------------------------------------------------------------------=
  603. // Checks recursively whether or not an object is up to date.
  604. //
  605. // Output:
  606. //    HRESULT        - S_OK, S_FALSE, OLE_E_UNVAILABLE
  607. //
  608. // Notes:
  609. //
  610. STDMETHODIMP COleControl::IsUpToDate
  611. (
  612.     void
  613. )
  614. {
  615.     // we're always up to date
  616.     //
  617.     return S_OK;
  618. }
  619.  
  620. //=--------------------------------------------------------------------------=
  621. // COleControl::GetUserClassID    [IOleObject]
  622. //=--------------------------------------------------------------------------=
  623. // Returns the controls class identifier, the CLSID corresponding to the
  624. // string identifying the object to an end user.
  625. //
  626. // Parameters:
  627. //    CLSID *      - [in] where to put the CLSID
  628. //
  629. // Output:
  630. //    HRESULT      - S_OK, E_FAIL
  631. //
  632. // Notes:
  633. //
  634. STDMETHODIMP COleControl::GetUserClassID
  635. (
  636.     CLSID *pclsid
  637. )
  638. {
  639.     // this is the same as IPersist::GetClassID
  640.     //
  641.     return GetClassID(pclsid);
  642. }
  643.  
  644. //=--------------------------------------------------------------------------=
  645. // COleControl::GetUserType    [IOleObject]
  646. //=--------------------------------------------------------------------------=
  647. // Retrieves the user-type name of the control for display in user-interface
  648. // elements such as menus, list boxes, and dialog boxes.
  649. //
  650. // Parameters:
  651. //    DWORD        - [in]  specifies the form of the type name.
  652. //    LPOLESTR *   - [out] where to put user type
  653. //
  654. // Output:
  655. //    HRESULT      - S_OK, OLE_S_USEREG, E_OUTOFMEMORY
  656. //
  657. // Notes:
  658. //
  659. STDMETHODIMP COleControl::GetUserType
  660. (
  661.     DWORD     dwFormOfType,
  662.     LPOLESTR *ppszUserType
  663. )
  664. {
  665.     *ppszUserType = OLESTRFROMANSI(NAMEOFOBJECT(m_ObjectType));
  666.     return (*ppszUserType) ? S_OK : E_OUTOFMEMORY;
  667. }
  668.  
  669. //=--------------------------------------------------------------------------=
  670. // COleControl::SetExtent    [IOleObject]
  671. //=--------------------------------------------------------------------------=
  672. // Informs the control of how much display space its container has assigned it.
  673. //
  674. // Parameters:
  675. //    DWORD            - [in] which form or 'aspect'  is to be displayed.
  676. //    SIZEL *          - [in] size limit for the control.
  677. //
  678. // Output:
  679. //    HRESULT          - S_OK, E_FAIL, OLE_E_NOTRUNNING
  680. //
  681. // Notes:
  682. //
  683. STDMETHODIMP COleControl::SetExtent
  684. (
  685.     DWORD  dwDrawAspect,
  686.     SIZEL *psizel
  687. )
  688. {
  689.     BOOL f;
  690.  
  691.     if (dwDrawAspect & DVASPECT_CONTENT) {
  692.  
  693.         // change the units to pixels, and resize the control.
  694.         //
  695.         HiMetricToPixel(psizel, &m_Size);
  696.  
  697.         // first call the user version.  if they return FALSE, they want
  698.         // to keep their current size
  699.         //
  700.         f = OnSetExtent(psizel);
  701.         if (!f) PixelToHiMetric(&m_Size, psizel);
  702.  
  703.         if (m_fInPlaceActive) {
  704.             RECT rect;
  705.  
  706.             GetWindowRect(m_hwnd, &rect);
  707.             MapWindowPoints(NULL, m_hwndParent, (LPPOINT)&rect, 2);
  708.             rect.right = rect.left + m_Size.cx;
  709.             rect.bottom = rect.top + m_Size.cy;
  710.             m_pInPlaceSite->OnPosRectChange(&rect);
  711.  
  712.             if (m_hwnd) {
  713.                 // just go and resize
  714.                 //
  715.                 if (m_hwndReflect)
  716.                     SetWindowPos(m_hwndReflect, 0, 0, 0, m_Size.cx, m_Size.cy,
  717.                                  SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  718.                 SetWindowPos(m_hwnd, 0, 0, 0, m_Size.cx, m_Size.cy,
  719.                              SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  720.             }
  721.         } else if (m_hwnd) {
  722.             SetWindowPos(m_hwnd, NULL, 0, 0, m_Size.cx, m_Size.cy, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  723.         } else {
  724.             ViewChanged();
  725.         }
  726.  
  727.         // return code depending on whether or not user accepted given
  728.         // size
  729.         //
  730.         return (f) ? S_OK : E_FAIL;
  731.  
  732.     } else {
  733.         // we don't support any other aspects.
  734.         //
  735.         return DV_E_DVASPECT;
  736.     }
  737.  
  738.     // dead code
  739.     FAIL("Gaaaaak! Dead Code!");
  740. }
  741.  
  742. //=--------------------------------------------------------------------------=
  743. // COleControl::GetExtent    [IOleObject]
  744. //=--------------------------------------------------------------------------=
  745. // Retrieves the control's current display size.
  746. //
  747. // Parameters:
  748. //    DWORD            - [in] aspect
  749. //    SIZEL *          - [in] where to put results
  750. //
  751. // Output:
  752. //    S_OK, E_INVALIDARG
  753. //
  754. // Notes:
  755. //
  756. STDMETHODIMP COleControl::GetExtent
  757. (
  758.     DWORD  dwDrawAspect,
  759.     SIZEL *pSizeLOut
  760. )
  761. {
  762.  
  763.     if (dwDrawAspect & DVASPECT_CONTENT) {
  764.         PixelToHiMetric((const SIZEL *)&m_Size, pSizeLOut);
  765.         return S_OK;
  766.     } else {
  767.         return DV_E_DVASPECT;
  768.     }
  769.  
  770.     // dead code
  771. }
  772.  
  773. //=--------------------------------------------------------------------------=
  774. // COleControl::Advise    [IOleObject]
  775. //=--------------------------------------------------------------------------=
  776. // establishes and advisory connection between the control and the container,
  777. // in which the control will notify the container of certain events.
  778. //
  779. // Parameters:
  780. //    IAdviseSink *     - [in]  advise sink of calling object
  781. //    DWORD             - [out] cookie
  782. //
  783. // Output:
  784. //    HRESULT           - S_OK, E_OUTOFMEMORY
  785. //
  786. // Notes:
  787. //
  788. STDMETHODIMP COleControl::Advise
  789. (
  790.     IAdviseSink *pAdviseSink,
  791.     DWORD       *pdwConnection
  792. )
  793. {
  794.     HRESULT hr;
  795.  
  796.     // if we haven't yet created a standard advise holder object, do so
  797.     // now
  798.     //
  799.     if (!m_pOleAdviseHolder) {
  800.         hr = CreateOleAdviseHolder(&m_pOleAdviseHolder);
  801.         RETURN_ON_FAILURE(hr);
  802.     }
  803.  
  804.     // just get it to do the work for us!
  805.     //
  806.     return m_pOleAdviseHolder->Advise(pAdviseSink, pdwConnection);
  807. }
  808.  
  809. //=--------------------------------------------------------------------------=
  810. // COleControl::Unadvise    [IOleObject]
  811. //=--------------------------------------------------------------------------=
  812. // Deletes a previously established advisory connection.
  813. //
  814. // Parameters:
  815. //    DWORD         - [in] connection cookie
  816. //
  817. // Output:
  818. //    HRESULT       - S_OK, E_FAIL, OLE_E_NOCONNECTION
  819. //
  820. // Notes:
  821. //
  822. STDMETHODIMP COleControl::Unadvise
  823. (
  824.     DWORD dwConnection
  825. )
  826. {
  827.     if (!m_pOleAdviseHolder) {
  828.         FAIL("Somebody called Unadvise on IOleObject without calling Advise!");
  829.         CONNECT_E_NOCONNECTION;
  830.     }
  831.  
  832.     return m_pOleAdviseHolder->Unadvise(dwConnection);
  833. }
  834.  
  835. //=--------------------------------------------------------------------------=
  836. // COleControl::EnumAdvise    [IOleObject]
  837. //=--------------------------------------------------------------------------=
  838. // Enumerates the advisory connections registered for an object, so a container
  839. // can know what to release prior to closing down.
  840. //
  841. // Parameters:
  842. //    IEnumSTATDATA **    - [out] where to put enumerator
  843. //
  844. // Output:
  845. //    HRESULT             - S_OK, E_FAIL, E_NOTIMPL
  846. //
  847. // Notes:
  848. //
  849. STDMETHODIMP COleControl::EnumAdvise
  850. (
  851.     IEnumSTATDATA **ppEnumOut
  852. )
  853. {
  854.     if (!m_pOleAdviseHolder) {
  855.         FAIL("Somebody Called EnumAdvise without setting up any connections");
  856.         *ppEnumOut = NULL;
  857.         return E_FAIL;
  858.     }
  859.  
  860.     return m_pOleAdviseHolder->EnumAdvise(ppEnumOut);
  861. }
  862.  
  863. //=--------------------------------------------------------------------------=
  864. // COleControl::GetMiscStatus    [IOleObject]
  865. //=--------------------------------------------------------------------------=
  866. // Returns a value indicating the status of an object at creation and loading.
  867. //
  868. // Parameters:
  869. //    DWORD         - [in]  aspect desired
  870. //    DWORD *       - [out] where to put the bits.
  871. //
  872. // Output:
  873. //    HRESULT       - S_OK, OLE_S_USEREG, CO_E_CLASSNOTREG, CO_E_READREGDB
  874. //
  875. // Notes:
  876. //
  877. STDMETHODIMP COleControl::GetMiscStatus
  878. (
  879.     DWORD  dwAspect,
  880.     DWORD *pdwStatus
  881. )
  882. {
  883.     CHECK_POINTER(pdwStatus);
  884.  
  885.     if (dwAspect == DVASPECT_CONTENT) {
  886.         *pdwStatus = OLEMISCFLAGSOFCONTROL(m_ObjectType);
  887.         return S_OK;
  888.     } else {
  889.         return DV_E_DVASPECT;
  890.     }
  891.  
  892.     // dead code
  893. }
  894.  
  895. //=--------------------------------------------------------------------------=
  896. // COleControl::SetColorScheme    [IOleObject]
  897. //=--------------------------------------------------------------------------=
  898. // Specifies the color palette that the object application should use when it
  899. // edits the specified object.
  900. //
  901. // Parameters:
  902. //    LOGPALETTE *     - [in] new palette
  903. //
  904. // Output:
  905. //    HRESULT          - S_OK, E_NOTIMPL, OLE_E_PALETTE, OLE_E_NOTRUNNING
  906. //
  907. // Notes:
  908. //    - we don't care.
  909. //
  910. STDMETHODIMP COleControl::SetColorScheme
  911. (
  912.     LOGPALETTE *pLogpal
  913. )
  914. {
  915.     // homey don't play that. ignore
  916.     //
  917.     return S_OK;
  918. }
  919.  
  920. //=--------------------------------------------------------------------------=
  921. // COleControl::GetWindow    [IOleWindow/IOleInPlaceObject]
  922. //=--------------------------------------------------------------------------=
  923. // Returns the window handle to one of the windows participating in in-place
  924. // activation (frame, document, parent, or in-place object window).
  925. //
  926. // Parameters:
  927. //    HWND *        - [out] where to return window handle.
  928. //
  929. // Output:
  930. //    HRESULT       - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED, E_FAIL
  931. //
  932. // Notes:
  933. //
  934. STDMETHODIMP COleControl::GetWindow
  935. (
  936.     HWND *phwnd
  937. )
  938. {
  939.     *phwnd = GetOuterWindow();
  940.  
  941.     return (*phwnd) ? S_OK : E_UNEXPECTED;
  942. }
  943.  
  944. //=--------------------------------------------------------------------------=
  945. // COleControl::ContextSensitiveHelp    [IOleWindow/IOleInPlaceObject]
  946. //=--------------------------------------------------------------------------=
  947. // Determines whether context-sensitive help mode should be entered during an
  948. // in-place activation session.
  949. //
  950. // Parameters:
  951. //    BOOL            - [in] whether or not to enter help mode.
  952. //
  953. // Output:
  954. //    HRESULT         - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED
  955. //
  956. // Notes:
  957. //
  958. STDMETHODIMP COleControl::ContextSensitiveHelp
  959. (
  960.     BOOL fEnterMode
  961. )
  962. {
  963.     // homey don't play that.
  964.     //
  965.     return E_NOTIMPL;
  966. }
  967.  
  968. //=--------------------------------------------------------------------------=
  969. // COleControl::InPlaceActivate
  970. //=--------------------------------------------------------------------------=
  971. // activates the control, and depending on the verb, optionally ui activates
  972. // it as well.
  973. //
  974. // Parameters:
  975. //    LONG         - [in] the verb that caused us to activate
  976. //
  977. // Output:
  978. //    HRESULT
  979. //
  980. // Notes:
  981. //
  982. HRESULT COleControl::InPlaceActivate
  983. (
  984.     LONG lVerb
  985. )
  986. {
  987.     HRESULT hr;
  988.  
  989.     // if we don't have a client site, then there's not much to do.
  990.     //
  991.     if (!m_pClientSite)
  992.         return S_OK;
  993.  
  994.     // get an InPlaceSite pointer
  995.     //
  996.     if (!m_pInPlaceSite) {
  997.         hr = m_pClientSite->QueryInterface(IID_IOleInPlaceSite, (void **)&m_pInPlaceSite);
  998.         RETURN_ON_FAILURE(hr);
  999.     }
  1000.  
  1001.     // if we're not already active, go and do it.
  1002.     //
  1003.     if (!m_fInPlaceActive) {
  1004.         OLEINPLACEFRAMEINFO InPlaceFrameInfo;
  1005.         RECT rcPos, rcClip;
  1006.  
  1007.         // ask for permission and notify the container we're going active.
  1008.         //
  1009.         hr = m_pInPlaceSite->CanInPlaceActivate();
  1010.         if (hr != S_OK) return (FAILED(hr)) ? E_FAIL : hr;
  1011.  
  1012.         hr = m_pInPlaceSite->OnInPlaceActivate();
  1013.         RETURN_ON_FAILURE(hr);
  1014.  
  1015.         m_fInPlaceActive = TRUE;
  1016.         InPlaceFrameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
  1017.  
  1018.         // get our parent window
  1019.         //
  1020.         hr = m_pInPlaceSite->GetWindow(&m_hwndParent);
  1021.         if (!FAILED(hr))
  1022.             // get our display and clipping rectangles
  1023.             //
  1024.             hr = m_pInPlaceSite->GetWindowContext(&m_pInPlaceFrame, &m_pInPlaceUIWindow,
  1025.                                                   &rcPos, &rcClip, &InPlaceFrameInfo);
  1026.         if (FAILED(hr)) {
  1027.             InPlaceDeactivate();
  1028.             return hr;
  1029.         }
  1030.  
  1031.         // make sure we'll display ourselves in the correct location with the correct size
  1032.         //
  1033.         SetInPlaceParent(m_hwndParent);
  1034.         SetObjectRects(&rcPos, &rcClip);
  1035.  
  1036.         // create the window, and display it.
  1037.         //
  1038.         CreateInPlaceWindow(rcPos.left, rcPos.top);
  1039.     }
  1040.  
  1041.     // if we're not inplace visible yet, do so now.
  1042.     //
  1043.     if (!m_fInPlaceVisible)
  1044.         SetInPlaceVisible(TRUE);
  1045.  
  1046.     // if we weren't asked to UIActivate, then we're done.
  1047.     //
  1048.     if (lVerb != OLEIVERB_PRIMARY && lVerb != OLEIVERB_UIACTIVATE)
  1049.         return S_OK;
  1050.  
  1051.     // if we're not already UI active, do sow now.
  1052.     //
  1053.     if (!m_fUIActive) {
  1054.         m_fUIActive = TRUE;
  1055.  
  1056.         // inform the container of our intent
  1057.         //
  1058.         m_pInPlaceSite->OnUIActivate();
  1059.  
  1060.         // take the focus  [which is what UI Activation is all about !]
  1061.         //
  1062.         SetFocus(m_hwnd);
  1063.  
  1064.         // set up the active object [us] with the container.
  1065.         //
  1066.         m_pInPlaceFrame->SetActiveObject((IOleInPlaceActiveObject *)this, NULL);
  1067.         if (m_pInPlaceUIWindow)
  1068.             m_pInPlaceUIWindow->SetActiveObject((IOleInPlaceActiveObject *)this, NULL);
  1069.  
  1070.         // we have to explicitly say we don't wany any border space.
  1071.         //
  1072.         m_pInPlaceFrame->SetBorderSpace(NULL);
  1073.         if (m_pInPlaceUIWindow)
  1074.             m_pInPlaceUIWindow->SetBorderSpace(NULL);
  1075.     }
  1076.  
  1077.     return S_OK;
  1078. }
  1079.  
  1080. //=--------------------------------------------------------------------------=
  1081. // COleControl::InPlaceDeactivate    [IOleInPlaceObject]
  1082. //=--------------------------------------------------------------------------=
  1083. // Deactivates an active in-place object and discards the object's undo state.
  1084. //
  1085. // Output:
  1086. //    HRESULT        - S_OK, E_UNEXPECTED
  1087. //
  1088. // Notes:
  1089. //
  1090. STDMETHODIMP COleControl::InPlaceDeactivate
  1091. (
  1092.     void
  1093. )
  1094. {
  1095.     // if we're not in-place active yet, then this is easy.
  1096.     //
  1097.     if (!m_fInPlaceActive)
  1098.         return S_OK;
  1099.  
  1100.     // transition from UIActive back to active
  1101.     //
  1102.     if (m_fUIActive)
  1103.         UIDeactivate();
  1104.  
  1105.     m_fInPlaceActive = FALSE;
  1106.     m_fInPlaceVisible = FALSE;
  1107.  
  1108.     // tell our window to go play with somebody else temporarily.
  1109.     //
  1110.     if (m_hwnd) {
  1111.         // so our window proc doesn't crash.
  1112.         //
  1113.         BeforeDestroyWindow();
  1114.         SetWindowLong(m_hwnd, GWL_USERDATA, 0xFFFFFFFF);
  1115.         DestroyWindow(m_hwnd);
  1116.         m_hwnd = NULL;
  1117.  
  1118.         if (m_hwndReflect) {
  1119.             SetWindowLong(m_hwndReflect, GWL_USERDATA, 0);
  1120.             DestroyWindow(m_hwndReflect);
  1121.             m_hwndReflect = NULL;
  1122.         }
  1123.     }
  1124.  
  1125.     RELEASE_OBJECT(m_pInPlaceFrame);
  1126.     RELEASE_OBJECT(m_pInPlaceUIWindow);
  1127.     m_pInPlaceSite->OnInPlaceDeactivate();
  1128.     return S_OK;
  1129. }
  1130.  
  1131. //=--------------------------------------------------------------------------=
  1132. // COleControl::UIDeactivate    [IOleInPlaceObject]
  1133. //=--------------------------------------------------------------------------=
  1134. // transitions us from UI Active to merely being active [visible]  for
  1135. // a control, this doesn't mean all that much.
  1136. //
  1137. // Output:
  1138. //    HRESULT         - S_OK, E_UNEXPECTED
  1139. //
  1140. // Notes:
  1141. //
  1142. STDMETHODIMP COleControl::UIDeactivate
  1143. (
  1144.     void
  1145. )
  1146. {
  1147.     // if we're not UIActive, not much to do.
  1148.     //
  1149.     if (!m_fUIActive)
  1150.         return S_OK;
  1151.  
  1152.     m_fUIActive = FALSE;
  1153.  
  1154.     // notify everybody that we're no longer UIActive
  1155.     //
  1156.     if (m_pInPlaceUIWindow) m_pInPlaceUIWindow->SetActiveObject(NULL, NULL);
  1157.     m_pInPlaceFrame->SetActiveObject(NULL, NULL);
  1158.  
  1159.     m_pInPlaceSite->OnUIDeactivate(FALSE);
  1160.  
  1161.     return S_OK;
  1162. }
  1163.  
  1164. //=--------------------------------------------------------------------------=
  1165. // COleControl::SetObjectRects    [IOleInPlaceObject]
  1166. //=--------------------------------------------------------------------------=
  1167. // Indicates how much of the control is visible.
  1168. //
  1169. // Parameters:
  1170. //    LPCRECT        - [in] position of the control.
  1171. //    LPCRECT        - [in] clipping rectangle for the control.
  1172. //
  1173. // Output:
  1174. //    HRESULT        - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED
  1175. //
  1176. // Notes:
  1177. //
  1178. STDMETHODIMP COleControl::SetObjectRects
  1179. (
  1180.     LPCRECT prcPos,
  1181.     LPCRECT prcClip
  1182. )
  1183. {
  1184.     BOOL fRemoveWindowRgn;
  1185.  
  1186.     // update our information
  1187.     //
  1188.     m_Size.cx = prcPos->right - prcPos->left;
  1189.     m_Size.cy = prcPos->bottom - prcPos->top;
  1190.  
  1191.     // move our window to the new location and handle clipping
  1192.     //
  1193.     if (m_hwnd) {
  1194.         fRemoveWindowRgn = m_fUsingWindowRgn;
  1195.         if (prcClip) {
  1196.             // the container wants us to clip, so figure out if we really
  1197.             // need to
  1198.             //
  1199.             RECT rcIXect;
  1200.             IntersectRect(&rcIXect, prcPos, prcClip);
  1201.             if (!EqualRect(&rcIXect, prcPos)) {
  1202.                 SetWindowRgn(GetOuterWindow(), CreateRectRgnIndirect(&rcIXect), TRUE);
  1203.                 m_fUsingWindowRgn = TRUE;
  1204.                 fRemoveWindowRgn  = FALSE;
  1205.             }
  1206.         }
  1207.  
  1208.         if (fRemoveWindowRgn) {
  1209.             SetWindowRgn(GetOuterWindow(), NULL, TRUE);
  1210.             m_fUsingWindowRgn = FALSE;
  1211.         }
  1212.  
  1213.         // set our control's location, but don't change it's size at all
  1214.         // [people for whom zooming is important should set that up here]
  1215.         //
  1216.         SetWindowPos(GetOuterWindow(), NULL, prcPos->left, prcPos->top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
  1217.     }
  1218.     return S_OK;
  1219. }
  1220.  
  1221. //=--------------------------------------------------------------------------=
  1222. // COleControl::ReactivateAndUndo    [IOleInPlaceObject]
  1223. //=--------------------------------------------------------------------------=
  1224. // Reactivates a previously deactivated object, undoing the last state of the object.
  1225. //
  1226. // Output:
  1227. //    HRESULT        - S_OK, E_NOTUNDOABLE
  1228. //
  1229. // Notes:
  1230. //
  1231. STDMETHODIMP COleControl::ReactivateAndUndo
  1232. (
  1233.     void
  1234. )
  1235. {
  1236.     // homey don't play that.
  1237.     //
  1238.     return E_NOTIMPL;
  1239. }
  1240.  
  1241. //=--------------------------------------------------------------------------=
  1242. // COleControl::TranslateAccelerator    [IOleInPlaceActiveObject]
  1243. //=--------------------------------------------------------------------------=
  1244. // Processes menu accelerator-key messages from the container's message queue.
  1245. //
  1246. // Parameters:
  1247. //    LPMSG            - [in] the message that has the special key in it.
  1248. //
  1249. // Output:
  1250. //    HRESULT          - S_OK, S_FALSE, E_UNEXPECTED
  1251. //
  1252. // Notes:
  1253. //
  1254. STDMETHODIMP COleControl::TranslateAccelerator
  1255. (
  1256.     LPMSG    pmsg
  1257. )
  1258. {
  1259.     // see if we want it or not.
  1260.     //
  1261.     if (OnSpecialKey(pmsg))
  1262.         return S_OK;
  1263.  
  1264.     // if not, then we want to forward it back to the site for further processing
  1265.     //
  1266.     if (m_pControlSite)
  1267.         return m_pControlSite->TranslateAccelerator(pmsg, _SpecialKeyState());
  1268.  
  1269.     // we didn't want it.
  1270.     //
  1271.     return S_FALSE;
  1272. }
  1273.  
  1274. //=--------------------------------------------------------------------------=
  1275. // COleControl::OnFrameWindowActivate    [IOleInPlaceActiveObject]
  1276. //=--------------------------------------------------------------------------=
  1277. // Notifies the control when the container's top-level frame window is
  1278. // activated or deactivated.
  1279. //
  1280. // Parameters:
  1281. //    BOOL        - [in] state of containers top level window.
  1282. //
  1283. // Output:
  1284. //    HRESULT     - S_OK
  1285. //
  1286. // Notes:
  1287. //    - we really don't care.
  1288. //
  1289. STDMETHODIMP COleControl::OnFrameWindowActivate
  1290. (
  1291.     BOOL fActivate
  1292. )
  1293. {
  1294.     // not interesting
  1295.     //
  1296.     return S_OK;
  1297. }
  1298.  
  1299. //=--------------------------------------------------------------------------=
  1300. // COleControl::OnDocWindowActivate    [IOleInPlaceActiveObject]
  1301. //=--------------------------------------------------------------------------=
  1302. // Notifies the active control when the container's document window is
  1303. // activated or deactivated.
  1304. //
  1305. // Parameters:
  1306. //    BOOL            - state of mdi child window.
  1307. //
  1308. // Output:
  1309. //    HRESULT         - S_OK
  1310. //
  1311. // Notes:
  1312. //
  1313. STDMETHODIMP COleControl::OnDocWindowActivate
  1314. (
  1315.     BOOL fActivate
  1316. )
  1317. {
  1318.     // apart from that, we don't do anything.
  1319.     //
  1320.     return S_OK;
  1321. }
  1322.  
  1323. //=--------------------------------------------------------------------------=
  1324. // COleControl::ResizeBorder    [IOleInPlaceActiveObject]
  1325. //=--------------------------------------------------------------------------=
  1326. // Alerts the control that it needs to resize its border space.
  1327. //
  1328. // Parameters:
  1329. //    LPCRECT               - [in] new outer rectangle for border space
  1330. //    IOleInPlaceUIWindow * - [in] the document or frame who's border has changed
  1331. //    BOOL                  - [in] true if it was the fram window taht called.
  1332. //
  1333. // Output:
  1334. //    HRESULT               - S_OK
  1335. //
  1336. // Notes:
  1337. //
  1338. STDMETHODIMP COleControl::ResizeBorder
  1339. (
  1340.     LPCRECT              prcBorder,
  1341.     IOleInPlaceUIWindow *pInPlaceUIWindow,
  1342.     BOOL                 fFrame
  1343. )
  1344. {
  1345.     // this is largely uninteresting to us, since we have no border.
  1346.     //
  1347.     return S_OK;
  1348. }
  1349.  
  1350. //=--------------------------------------------------------------------------=
  1351. // COleControl::EnableModeless    [IOleInPlaceActiveObject]
  1352. //=--------------------------------------------------------------------------=
  1353. // Enables or disables modeless dialog boxes when the container creates or
  1354. // destroys a modal dialog box.
  1355. //
  1356. // Parameters:
  1357. //    BOOL            - [in] enable or disable modeless dialogs.
  1358. //
  1359. // Output:
  1360. //    HRESULT         - S_OK
  1361. //
  1362. // Notes:
  1363. //
  1364. STDMETHODIMP COleControl::EnableModeless
  1365. (
  1366.     BOOL fEnable
  1367. )
  1368. {
  1369.     // phenomenally uninteresting
  1370.     //
  1371.     return S_OK;
  1372. }
  1373.  
  1374. //=--------------------------------------------------------------------------=
  1375. // COleControl::Draw    [IViewObject2]
  1376. //=--------------------------------------------------------------------------=
  1377. // Draws a representation of an object onto the specified device context. 
  1378. //
  1379. // Parameters:
  1380. //    DWORD                - [in] draw aspect
  1381. //    LONG                 - [in] part of object to draw [not relevant]
  1382. //    void *               - NULL
  1383. //    DVTARGETDEVICE *     - [in] specifies the target device
  1384. //    HDC                  - [in] information context for target device
  1385. //    HDC                  - [in] target device context
  1386. //    LPCRECTL             - [in] rectangle in which the object is drawn
  1387. //    LPCRECTL             - [in] window extent and origin for metafiles
  1388. //    BOOL (*)(DWORD)      - [in] callback for continuing or cancelling drawing
  1389. //    DWORD                - [in] parameter to pass to callback.
  1390. //
  1391. // Output:
  1392. //    HRESULT
  1393. //
  1394. // Notes:
  1395. //
  1396. STDMETHODIMP COleControl::Draw
  1397. (
  1398.     DWORD            dwDrawAspect,
  1399.     LONG             lIndex,
  1400.     void            *IgnoreMe,
  1401.     DVTARGETDEVICE  *ptd,
  1402.     HDC              hicTargetDevice,
  1403.     HDC              hdcDraw,
  1404.     LPCRECTL         prcBounds,
  1405.     LPCRECTL         prcWBounds,
  1406.     BOOL (__stdcall *pfnContinue)(DWORD dwContinue),
  1407.     DWORD            dwContinue
  1408. )
  1409. {
  1410.     HRESULT hr;
  1411.     RECTL rc;
  1412.     POINT pVp, pW;
  1413.     int iMode;
  1414.  
  1415.     // we only support one aspect
  1416.     //
  1417.     if (dwDrawAspect != DVASPECT_CONTENT)
  1418.         return DV_E_DVASPECT;
  1419.  
  1420.     // first -- convert the DC back to MM_TEXT mapping mode so that the
  1421.     // window proc and OnDraw can share the same painting code.  save
  1422.     // some information on it, so we can restore it later [without using
  1423.     // a SaveDC/RestoreDC]
  1424.     //
  1425.     rc = *prcBounds;
  1426.     LPtoDP(hdcDraw, (POINT *)&rc, 2);
  1427.  
  1428.     GetViewportOrgEx(hdcDraw, &pVp);
  1429.     GetWindowOrgEx(hdcDraw, &pW);
  1430.  
  1431.     SetViewportOrgEx(hdcDraw, 0, 0, NULL);
  1432.     SetWindowOrgEx(hdcDraw, 0, 0, NULL);
  1433.     iMode = SetMapMode(hdcDraw, MM_TEXT);
  1434.  
  1435.     // defer to the overridable OnDraw
  1436.     //
  1437.     hr = OnDraw(hdcDraw, &rc, &rc, hicTargetDevice);
  1438.  
  1439.     SetViewportOrgEx(hdcDraw, pVp.x, pVp.y, NULL);
  1440.     SetWindowOrgEx(hdcDraw, pW.x, pW.y, NULL);
  1441.     SetMapMode(hdcDraw, iMode);
  1442.     return hr;
  1443. }
  1444.  
  1445. //=--------------------------------------------------------------------------=
  1446. // COleControl::DoSuperClassPaint
  1447. //=--------------------------------------------------------------------------=
  1448. // design time painting of a subclassed control.
  1449. //
  1450. // Parameters:
  1451. //    HDC                - [in]  dc to work with
  1452. //    LPCRECTL           - [in]  rectangle to paint to.  should be in pixels
  1453. //
  1454. // Output:
  1455. //    HRESULT
  1456. //
  1457. // Notes:
  1458. //
  1459. HRESULT COleControl::DoSuperClassPaint
  1460. (
  1461.     HDC      hdc,
  1462.     LPCRECTL prcBounds
  1463. )
  1464. {
  1465.     HWND hwnd;
  1466.     RECT rcClient;
  1467.     int  iMapMode;
  1468.     POINT ptWOrg, ptVOrg;
  1469.     SIZE  sWOrg, sVOrg;
  1470.  
  1471.     // make sure we have a window.
  1472.     //
  1473.     hwnd = CreateInPlaceWindow(0,0);
  1474.     if (!hwnd)
  1475.         return E_FAIL;
  1476.  
  1477.     GetClientRect(hwnd, &rcClient);
  1478.  
  1479.     // set up the DC for painting.  this code largely taken from the MFC CDK
  1480.     // DoSuperClassPaint() fn
  1481.     //
  1482.     iMapMode = SetMapMode(hdc, MM_ANISOTROPIC);
  1483.     SetWindowOrgEx(hdc, 0, 0, &ptWOrg);
  1484.     SetWindowExtEx(hdc, rcClient.right, rcClient.bottom, &sWOrg);
  1485.     SetViewportOrgEx(hdc, prcBounds->left, prcBounds->top, &ptVOrg);
  1486.     SetViewportExtEx(hdc, prcBounds->right - prcBounds->left, prcBounds->bottom - prcBounds->top, &sVOrg);
  1487.  
  1488. #if STRICT
  1489.     CallWindowProc((WNDPROC)SUBCLASSWNDPROCOFCONTROL(m_ObjectType), hwnd, (g_fSysWin95Shell) ? WM_PRINT : WM_PAINT, (WPARAM)hdc, (LPARAM)(g_fSysWin95Shell ? PRF_CHILDREN | PRF_CLIENT : 0));
  1490. #else
  1491.     CallWindowProc((FARPROC)SUBCLASSWNDPROCOFCONTROL(m_ObjectType), hwnd, (g_fSysWin95Shell) ? WM_PRINT : WM_PAINT, (WPARAM)hdc, (LPARAM)(g_fSysWin95Shell ? PRF_CHILDREN | PRF_CLIENT : 0));
  1492. #endif // STRICT
  1493.  
  1494.     return S_OK;
  1495. }
  1496.  
  1497.  
  1498. //=--------------------------------------------------------------------------=
  1499. // COleControl::GetColorSet    [IViewObject2]
  1500. //=--------------------------------------------------------------------------=
  1501. // Returns the logical palette that the control will use for drawing in its
  1502. // IViewObject::Draw method with the corresponding parameters.
  1503. //
  1504. // Parameters:
  1505. //    DWORD                - [in]  how the object is to be represented
  1506. //    LONG                 - [in]  part of the object to draw [not relevant]
  1507. //    void *               - NULL
  1508. //    DVTARGETDEVICE *     - [in]  specifies the target device
  1509. //    HDC                  - [in]  information context for the target device
  1510. //    LOGPALETTE **        - [out] where to put palette
  1511. //
  1512. // Output:
  1513. //    HRESULT              - S_OK, S_FALSE
  1514. //
  1515. // Notes:
  1516. //
  1517. STDMETHODIMP COleControl::GetColorSet
  1518. (
  1519.     DWORD            dwDrawAspect,
  1520.     LONG             lindex,
  1521.     void            *IgnoreMe,
  1522.     DVTARGETDEVICE  *ptd,
  1523.     HDC              hicTargetDevice,
  1524.     LOGPALETTE     **ppColorSet
  1525. )
  1526. {
  1527.     if (dwDrawAspect != DVASPECT_CONTENT)
  1528.         return DV_E_DVASPECT;
  1529.  
  1530.     *ppColorSet = NULL;
  1531.     return (OnGetPalette(hicTargetDevice, ppColorSet)) ? S_OK : S_FALSE;
  1532. }
  1533.  
  1534. //=--------------------------------------------------------------------------=
  1535. // COleControl::Freeze    [IViewObject2]
  1536. //=--------------------------------------------------------------------------=
  1537. // Freezes a certain aspect of the object's presentation so that it does not
  1538. // change until the IViewObject::Unfreeze method is called.
  1539. //
  1540. // Parameters:
  1541. //    DWORD            - [in] aspect
  1542. //    LONG             - [in] part of object to draw
  1543. //    void *           - NULL
  1544. //    DWORD *          - [out] for Unfreeze
  1545. //
  1546. // Output:
  1547. //    HRESULT
  1548. //
  1549. // Notes:
  1550. //
  1551. STDMETHODIMP COleControl::Freeze
  1552. (
  1553.     DWORD   dwDrawAspect,
  1554.     LONG    lIndex,
  1555.     void   *IgnoreMe,
  1556.     DWORD  *pdwFreeze
  1557. )
  1558. {
  1559.     // homey don't play that
  1560.     //
  1561.     return E_NOTIMPL;
  1562. }
  1563.  
  1564. //=--------------------------------------------------------------------------=
  1565. // COleControl::Unfreeze    [IVewObject2]
  1566. //=--------------------------------------------------------------------------=
  1567. // Releases a previously frozen drawing. The most common use of this method
  1568. // is for banded printing.
  1569. //
  1570. // Parameters:
  1571. //    DWORD        - [in] cookie from freeze
  1572. //
  1573. // Output:
  1574. //    HRESULT
  1575. //
  1576. // Notes:
  1577. //
  1578. STDMETHODIMP COleControl::Unfreeze
  1579. (
  1580.     DWORD dwFreeze
  1581. )
  1582. {
  1583.     // homey don't play that.
  1584.     //
  1585.     return E_NOTIMPL;
  1586. }
  1587.  
  1588. //=--------------------------------------------------------------------------=
  1589. // COleControl::SetAdvise    [IViewObject2]
  1590. //=--------------------------------------------------------------------------=
  1591. // Sets up a connection between the control and an advise sink so that the
  1592. // advise sink can be notified about changes in the control's view.
  1593. //
  1594. // Parameters:
  1595. //    DWORD            - [in] aspect
  1596. //    DWORD            - [in] info about the sink
  1597. //    IAdviseSink *    - [in] the sink
  1598. //
  1599. // Output:
  1600. //    HRESULT
  1601. //
  1602. // Notes:
  1603. //
  1604. STDMETHODIMP COleControl::SetAdvise
  1605. (
  1606.     DWORD        dwAspects,
  1607.     DWORD        dwAdviseFlags,
  1608.     IAdviseSink *pAdviseSink
  1609. )
  1610. {
  1611.     // if it's not a content aspect, we don't support it.
  1612.     //
  1613.     if (!(dwAspects & DVASPECT_CONTENT)) {
  1614.         return DV_E_DVASPECT;
  1615.     }
  1616.  
  1617.     // set up some flags  [we gotta stash for GetAdvise ...]
  1618.     //
  1619.     m_fViewAdvisePrimeFirst = (dwAdviseFlags & ADVF_PRIMEFIRST) ? TRUE : FALSE;
  1620.     m_fViewAdviseOnlyOnce = (dwAdviseFlags & ADVF_ONLYONCE) ? TRUE : FALSE;
  1621.  
  1622.     RELEASE_OBJECT(m_pViewAdviseSink);
  1623.     m_pViewAdviseSink = pAdviseSink;
  1624.     ADDREF_OBJECT(m_pViewAdviseSink);
  1625.  
  1626.     // prime them if they want it [we need to store this so they can get flags later]
  1627.     //
  1628.     if (m_fViewAdvisePrimeFirst)
  1629.         ViewChanged();
  1630.  
  1631.     return S_OK;
  1632. }
  1633.  
  1634. //=--------------------------------------------------------------------------=
  1635. // COleControl::GetAdvise    [IViewObject2]
  1636. //=--------------------------------------------------------------------------=
  1637. // Retrieves the existing advisory connection on the control if there is one.
  1638. // This method simply returns the parameters used in the most recent call to
  1639. // the IViewObject::SetAdvise method.
  1640. //
  1641. // Parameters:
  1642. //    DWORD *            - [out]  aspects
  1643. //    DWORD *            - [out]  advise flags
  1644. //    IAdviseSink **     - [out]  the sink
  1645. //
  1646. // Output:
  1647. //    HRESULT
  1648. //
  1649. // Notes;
  1650. //
  1651. STDMETHODIMP COleControl::GetAdvise
  1652. (
  1653.     DWORD        *pdwAspects,
  1654.     DWORD        *pdwAdviseFlags,
  1655.     IAdviseSink **ppAdviseSink
  1656. )
  1657. {
  1658.     // if they want it, give it to them
  1659.     //
  1660.     if (pdwAspects)
  1661.         *pdwAspects = DVASPECT_CONTENT;
  1662.  
  1663.     if (pdwAdviseFlags) {
  1664.         *pdwAdviseFlags = 0;
  1665.         if (m_fViewAdviseOnlyOnce) *pdwAdviseFlags |= ADVF_ONLYONCE;
  1666.         if (m_fViewAdvisePrimeFirst) *pdwAdviseFlags |= ADVF_PRIMEFIRST;
  1667.     }
  1668.  
  1669.     if (ppAdviseSink) {
  1670.         *ppAdviseSink = m_pViewAdviseSink;
  1671.         ADDREF_OBJECT(*ppAdviseSink);
  1672.     }
  1673.  
  1674.     return S_OK;
  1675. }
  1676.  
  1677. //=--------------------------------------------------------------------------=
  1678. // COleControl::GetExtent    [IViewObject2]
  1679. //=--------------------------------------------------------------------------=
  1680. // Returns the size that the control will be drawn on the
  1681. // specified target device.
  1682. //
  1683. // Parameters:
  1684. //    DWORD            - [in] draw aspect
  1685. //    LONG             - [in] part of object to draw
  1686. //    DVTARGETDEVICE * - [in] information about target device
  1687. //    LPSIZEL          - [out] where to put the size
  1688. //
  1689. // Output:
  1690. //    HRESULT
  1691. //
  1692. // Notes:
  1693. //
  1694. STDMETHODIMP COleControl::GetExtent
  1695. (
  1696.     DWORD           dwDrawAspect,
  1697.     LONG            lindex,
  1698.     DVTARGETDEVICE *ptd,
  1699.     LPSIZEL         psizel
  1700. )
  1701. {
  1702.     // we already have an implementation of this [from IOleObject]
  1703.     //
  1704.     return GetExtent(dwDrawAspect, psizel);
  1705. }
  1706.  
  1707. //=--------------------------------------------------------------------------=
  1708. // COleControl::GetClassInfo    [IProvideClassInfo]
  1709. //=--------------------------------------------------------------------------=
  1710. // returns the TypeInfo for the control's coclass.
  1711. //
  1712. // Parameters:
  1713. //    ITypeInfo **        - [out]
  1714. //
  1715. // Output:
  1716. //    HRESULT
  1717. //
  1718. // Notes:
  1719. //
  1720. STDMETHODIMP COleControl::GetClassInfo
  1721. (
  1722.     ITypeInfo **ppTypeInfo
  1723. )
  1724. {
  1725.     ITypeLib *pTypeLib;
  1726.     HRESULT hr;
  1727.  
  1728.     CHECK_POINTER(ppTypeInfo);
  1729.     *ppTypeInfo = NULL;
  1730.  
  1731.     // go and get our type library.
  1732.     // CONSIDER: - go to the same sorta scheme that we use for TypeInfo caching.
  1733.     // CONSIDER: - consider trying to register our typelib if this fails.
  1734.     //
  1735.     hr = LoadRegTypeLib(*g_pLibid, (USHORT)VERSIONOFOBJECT(m_ObjectType), 0,
  1736.                         LANGIDFROMLCID(g_lcidLocale), &pTypeLib);
  1737.     RETURN_ON_FAILURE(hr);
  1738.  
  1739.     // got the typelib.  get typeinfo for our coclass.
  1740.     //
  1741.     hr = pTypeLib->GetTypeInfoOfGuid((REFIID)CLSIDOFOBJECT(m_ObjectType), ppTypeInfo);
  1742.     pTypeLib->Release();
  1743.     RETURN_ON_FAILURE(hr);
  1744.  
  1745.     return S_OK;
  1746. }
  1747.  
  1748. //=--------------------------------------------------------------------------=
  1749. // COleControl::ViewChange    [callable]
  1750. //=--------------------------------------------------------------------------=
  1751. // called whenever the view of the object has changed.
  1752. //
  1753. // Notes:
  1754. //
  1755. void COleControl::ViewChanged
  1756. (
  1757.     void
  1758. )
  1759. {
  1760.     // send the view change notification to anybody listening.
  1761.     //
  1762.     if (m_pViewAdviseSink) {
  1763.         m_pViewAdviseSink->OnViewChange(DVASPECT_CONTENT, -1);
  1764.  
  1765.         // if they only asked to be advised once, kill the connection
  1766.         //
  1767.         if (m_fViewAdviseOnlyOnce)
  1768.             SetAdvise(DVASPECT_CONTENT, 0, NULL);
  1769.     }
  1770. }
  1771.  
  1772. //=--------------------------------------------------------------------------=
  1773. // COleControl::SetInPlaceVisible    [helper]
  1774. //=--------------------------------------------------------------------------=
  1775. // controls the visibility of the control window.
  1776. //
  1777. // Parameters:
  1778. //    BOOL        - TRUE shows FALSE hides.
  1779. //
  1780. // Notes:
  1781. //
  1782. void COleControl::SetInPlaceVisible
  1783. (
  1784.     BOOL fShow
  1785. )
  1786. {
  1787.     BOOL fVisible;
  1788.  
  1789.     m_fInPlaceVisible = fShow;
  1790.  
  1791.     // don't do anything if we don't have a window.  otherwise, set it
  1792.     //
  1793.     if (m_hwnd) {
  1794.         fVisible = ((GetWindowLong(GetOuterWindow(), GWL_STYLE) & WS_VISIBLE) != 0);
  1795.  
  1796.         if (fVisible && !fShow)
  1797.             ShowWindow(GetOuterWindow(), SW_HIDE);
  1798.         else if (!fVisible && fShow)
  1799.             ShowWindow(GetOuterWindow(), SW_SHOWNA);
  1800.     }
  1801. }
  1802.  
  1803. //=--------------------------------------------------------------------------=
  1804. // COleControl::AmbientPropertyChanged [overridable]
  1805. //=--------------------------------------------------------------------------=
  1806. // a method that derived controls can override to do whatever they want.
  1807. // we don't particularily care about this event.
  1808. //
  1809. // Parameters:
  1810. //    DISPID            - [in] dispid of prop that changed.
  1811. //
  1812. // Notes:
  1813. //
  1814. void COleControl::AmbientPropertyChanged
  1815. (
  1816.     DISPID dispid
  1817. )
  1818. {
  1819.     // do nothing
  1820. }
  1821.  
  1822. //=--------------------------------------------------------------------------=
  1823. // COleControl::DoCustomVerb    [overridable]
  1824. //=--------------------------------------------------------------------------=
  1825. // we were asked to execute a verb we don't know about right away.  see if
  1826. // it's a verb that the dervied-control defined.
  1827. //
  1828. // Parameters:
  1829. //    LONG            - [in] the verb.
  1830. //
  1831. // Output:
  1832. //    HRESULT         - S_OK, OLEOBJ_S_INVALIDVERB
  1833. //
  1834. // Notes:
  1835. //
  1836. HRESULT COleControl::DoCustomVerb
  1837. (
  1838.     LONG    lVerb
  1839. )
  1840. {
  1841.     return OLEOBJ_S_INVALIDVERB;
  1842. }
  1843.  
  1844. //=--------------------------------------------------------------------------=
  1845. // COleControl::OnSetExtent    [overridable]
  1846. //=--------------------------------------------------------------------------=
  1847. // let the user do something in the resize, if they care.
  1848. //
  1849. // Parameters:
  1850. //    SIZEL *        - [in] new values.
  1851. //
  1852. // Output:
  1853. //    BOOL           - FALSE means keep current size
  1854. //
  1855. // Notes:
  1856. //
  1857. BOOL COleControl::OnSetExtent
  1858. (
  1859.     SIZEL *pSizeL
  1860. )
  1861. {
  1862.     return TRUE;
  1863. }
  1864.  
  1865. //=--------------------------------------------------------------------------=
  1866. // COleControl::OnSpecialKey    [overridable]
  1867. //=--------------------------------------------------------------------------=
  1868. // allows controls to handle special keys such as arrows, CTRL+, etc ...
  1869. //
  1870. // Parameters:
  1871. //    LPMSG        - [in] the special key msg.
  1872. //
  1873. // Output:
  1874. //    BOOL         - TRUE we processed it, FALSE we didn't.
  1875. //
  1876. // Notes:
  1877. //
  1878. BOOL COleControl::OnSpecialKey
  1879. (
  1880.     LPMSG pmsg
  1881. )
  1882. {
  1883.     // do nothing.
  1884.     //
  1885.     return FALSE;
  1886. }
  1887.  
  1888. //=--------------------------------------------------------------------------=
  1889. // COleControl::ModalDialog    [callable, utility]
  1890. //=--------------------------------------------------------------------------=
  1891. // should be called when the control is about to show and hide a modal dialog.
  1892. //
  1893. // Parameters:
  1894. //    BOOL        - [in] true means showing a modal dialog, false means done
  1895. //
  1896. // Notes:
  1897. //
  1898. void COleControl::ModalDialog
  1899. (
  1900.     BOOL fShow
  1901. )
  1902. {
  1903.     // notify the container of our intention to show a modal dialog...
  1904.     //
  1905.     if (m_pInPlaceFrame)
  1906.         m_pInPlaceFrame->EnableModeless(!fShow);
  1907. }
  1908.  
  1909. //=--------------------------------------------------------------------------=
  1910. // COleControl::BeforeDestroyWindow    [overridable]
  1911. //=--------------------------------------------------------------------------=
  1912. // called just before we destroy a window.  gives the user the opportunity to
  1913. // save information out, especially if they're a subclassed control, and this
  1914. // is an interesting thing to do.
  1915. //
  1916. // Notes:
  1917. //
  1918. void COleControl::BeforeDestroyWindow
  1919. (
  1920.     void
  1921. )
  1922. {
  1923.     // fweeee
  1924. }
  1925.  
  1926. //=--------------------------------------------------------------------------=
  1927. // COleControl::BeforeCreateWindow    [overridable]
  1928. //=--------------------------------------------------------------------------=
  1929. // called just before we create a window.  the user should register their
  1930. // window class here, and set up any other things, such as the title of
  1931. // the window, and/or sytle bits, etc ...
  1932. //
  1933. // Notes:
  1934. //
  1935. void COleControl::BeforeCreateWindow
  1936. (
  1937.     void
  1938. )
  1939. {
  1940.     // blaugh
  1941. }
  1942.  
  1943.  
  1944. //=--------------------------------------------------------------------------=
  1945. // COleControl::OnGetPalette    [overridable]
  1946. //=--------------------------------------------------------------------------=
  1947. // called when the host wants palette information.  ideally, people should use
  1948. // this sparingly and carefully.
  1949. //
  1950. // Parameters:
  1951. //    HDC            - [in]  HIC for the target device
  1952. //    LOGPALETTE **  - [out] where to put the palette
  1953. //
  1954. // Output:
  1955. //    BOOL           - TRUE means we processed it, false means nope.
  1956. //
  1957. // Notes:
  1958. //
  1959. BOOL COleControl::OnGetPalette
  1960. (
  1961.     HDC          hicTargetDevice,
  1962.     LOGPALETTE **ppColorSet
  1963. )
  1964. {
  1965.     return FALSE;
  1966. }
  1967.